home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / printing / pnmtoprt.0 / pnmtoprt / pnmtoprt-2.0 / pnmread.c < prev    next >
C/C++ Source or Header  |  1996-03-28  |  11KB  |  653 lines
  1. #include <stdio.h>
  2. #include "pnmread.h"
  3.  
  4.  
  5. static Pnm_Info pnm_info;
  6.  
  7. #ifdef __STDC__
  8. static int ppm_get_pixel_mono_binary(int *pixel, FILE *fd)
  9. #else
  10. static int ppm_get_pixel_mono_binary(pixel, fd)
  11. int *pixel;
  12. FILE *fd;
  13. #endif
  14. {
  15.   char red, green, blue;
  16.  
  17.   if(pixel) {
  18.     fread(&red, 1, 1, fd);
  19.     fread(&green, 1, 1, fd);
  20.     fread(&blue, 1, 1, fd);
  21.  
  22.     *pixel = (red != (char)pnm_info.colors) ||
  23.       (green != (char)pnm_info.colors) ||
  24.       (blue != (char)pnm_info.colors);;
  25.   }
  26.  
  27.   return(0);
  28. }
  29.  
  30. #ifdef __STDC__
  31. static int ppm_get_pixel_mono_ascii(int *pixel, FILE *fd)
  32. #else
  33. static int ppm_get_pixel_mono_ascii(pixel, fd)
  34. int *pixel;
  35. FILE *fd;
  36. #endif
  37. {
  38.   int z;
  39.   long red, green, blue;
  40.   int state;
  41.  
  42.   state = 0;
  43.   if(pixel) {
  44.     while(1) {
  45.       switch(z = fgetc(fd)) {
  46.  
  47.     /* ignore whitespaces */
  48.       case ' ':
  49.       case '\t':
  50.       case '\n':
  51.       case '\r':
  52.     break;
  53.  
  54.     /* ignoring lines with # */
  55.       case '#':
  56.     while((z = fgetc(fd)) != '\n' && z != EOF);
  57.     break;
  58.  
  59.       default:
  60.     switch(state) {
  61.     case 0:
  62.       ungetc(z, fd);
  63.       fscanf(fd, "%ld", &red);
  64.       state++;
  65.       break;
  66.     case 1:
  67.       ungetc(z, fd);
  68.       fscanf(fd, "%ld", &green);
  69.       state++;
  70.       break;
  71.     case 2:
  72.       ungetc(z, fd);
  73.       fscanf(fd, "%ld", &blue);
  74.       *pixel = (red != pnm_info.colors) ||
  75.         (green != pnm_info.colors) ||
  76.         (blue != pnm_info.colors);;
  77.       return(0);
  78.       break;
  79.     }
  80.     break;
  81.  
  82.       case EOF:
  83.     return(1);
  84.       }
  85.     }
  86.   }
  87.  
  88.   return(0);
  89. }
  90.  
  91. #ifdef __STDC__
  92. static int pgm_get_pixel_mono_binary(int *pixel, FILE *fd)
  93. #else
  94. static int pgm_get_pixel_mono_binary(pixel, fd)
  95. int *pixel;
  96. FILE *fd;
  97. #endif
  98. {
  99.   char c;
  100.  
  101.   if(pixel) {
  102.     fread(&c, 1, 1, fd);
  103.  
  104.     *pixel = (c != (char)pnm_info.colors);
  105.   }
  106.  
  107.   return(0);
  108. }
  109.  
  110. #ifdef __STDC__
  111. static int pgm_get_pixel_mono_ascii(int *pixel, FILE *fd)
  112. #else
  113. static int pgm_get_pixel_mono_ascii(pixel, fd)
  114. int *pixel;
  115. FILE *fd;
  116. #endif
  117. {
  118.   int z;
  119.   long lz;
  120.  
  121.   if(pixel) {
  122.     while(1) {
  123.       switch(z = fgetc(fd)) {
  124.  
  125.     /* ignore whitespaces */
  126.       case ' ':
  127.       case '\t':
  128.       case '\n':
  129.       case '\r':
  130.     break;
  131.  
  132.     /* ignoring lines with # */
  133.       case '#':
  134.     while((z = fgetc(fd)) != '\n' && z != EOF);
  135.     break;
  136.  
  137.       default:
  138.     ungetc(z, fd);
  139.     fscanf(fd, "%ld", &lz);
  140.     *pixel = (lz != pnm_info.colors);
  141.     return(0);
  142.  
  143.       case EOF:
  144.     return(1);
  145.       }
  146.     }
  147.   }
  148.  
  149.   return(0);
  150. }
  151.  
  152. #ifdef __STDC__
  153. static int pbm_get_pixel_mono_binary(int *pixel, FILE *fd)
  154. #else
  155. static int pbm_get_pixel_mono_binary(pixel, fd)
  156. int *pixel;
  157. FILE *fd;
  158. #endif
  159. {
  160.   static int bit = 8;
  161.   static char c;
  162.  
  163.   /* for masking the right bit */
  164.   static char bit_value[8] = {
  165.     128,
  166.     64,
  167.     32,
  168.     16,
  169.     8,
  170.     4,
  171.     2,
  172.     1
  173.   };
  174.  
  175.   if(pixel) {
  176.     if(bit > 7) {
  177.       bit = 0;
  178.       fread(&c, 1, 1, fd);
  179.     }
  180.  
  181.     *pixel = c & bit_value[bit++];
  182.   } else {
  183.     /* end of scan line */
  184.     if(bit) {
  185.       bit = 8;
  186.     }
  187.   }
  188.  
  189.   return(0);
  190. }
  191.  
  192. #ifdef __STDC__
  193. static int pbm_get_pixel_mono_ascii(int *pixel, FILE *fd)
  194. #else
  195. static int pbm_get_pixel_mono_ascii(pixel, fd)
  196. int *pixel;
  197. FILE *fd;
  198. #endif
  199. {
  200.   int z;
  201.  
  202.   if(pixel) {
  203.     while(1) {
  204.       switch(fgetc(fd)) {
  205.  
  206.     /* ignore whitespaces */
  207.       case ' ':
  208.       case '\t':
  209.       case '\n':
  210.       case '\r':
  211.     break;
  212.  
  213.     /* ignoring lines with # */
  214.       case '#':
  215.     while((z = fgetc(fd)) != '\n' && z != EOF);
  216.     break;
  217.  
  218.       case '1':
  219.     *pixel = 1;
  220.     return(0);
  221.  
  222.       case '0':
  223.     *pixel = 0;
  224.     return(0);
  225.  
  226.       default:
  227.     return(1);
  228.       }
  229.     }
  230.   }
  231. }
  232.  
  233. #ifdef __STDC__
  234. static int ppm_get_pixel_color_binary(int *pixel_yellow, int *pixel_red,
  235.                       int *pixel_blue, int *pixel_black,
  236.                       FILE *fd)
  237. #else
  238. static int ppm_get_pixel_color_binary(pixel_yellow, pixel_red,
  239.                       pixel_blue, pixel_black,
  240.                       fd)
  241. int *pixel_yellow;
  242. int *pixel_red;
  243. int *pixel_blue;
  244. int *pixel_black;
  245. FILE *fd;
  246. #endif
  247. {
  248.   char red, green, blue;
  249.  
  250.   if(pixel_yellow) {
  251.  
  252.     fread(&red, 1, 1, fd);
  253.     fread(&green, 1, 1, fd);
  254.     fread(&blue, 1, 1, fd);
  255.  
  256.     *pixel_black  = 0;
  257.     *pixel_red    = (green != (char)pnm_info.colors);
  258.     *pixel_blue   = (red   != (char)pnm_info.colors);
  259.     *pixel_yellow = (blue  != (char)pnm_info.colors);
  260.  
  261.     if(*pixel_red && *pixel_blue && *pixel_yellow) {
  262.       *pixel_black = 1;
  263.       *pixel_yellow = *pixel_red = *pixel_blue = 0;
  264.     }
  265.   }
  266.  
  267.   return(0);
  268. }
  269.  
  270. #ifdef __STDC__
  271. static int ppm_get_pixel_color_ascii(int *pixel_yellow, int *pixel_red,
  272.                      int *pixel_blue, int *pixel_black,
  273.                      FILE *fd)
  274. #else
  275. static int ppm_get_pixel_color_ascii(pixel_yellow, pixel_red,
  276.                      pixel_blue, pixel_black,
  277.                      fd)
  278. int *pixel_yellow;
  279. int *pixel_red;
  280. int *pixel_blue;
  281. int *pixel_black;
  282. FILE *fd;
  283. #endif
  284. {
  285.   int z;
  286.   long red, green, blue;
  287.   int state;
  288.  
  289.   state = 0;
  290.   if(pixel_yellow) {
  291.     while(1) {
  292.       switch(z = fgetc(fd)) {
  293.  
  294.     /* ignore whitespaces */
  295.       case ' ':
  296.       case '\t':
  297.       case '\n':
  298.       case '\r':
  299.     break;
  300.  
  301.     /* ignoring lines with # */
  302.       case '#':
  303.     while((z = fgetc(fd)) != '\n' && z != EOF);
  304.     break;
  305.  
  306.       default:
  307.     switch(state) {
  308.     case 0:
  309.       ungetc(z, fd);
  310.       fscanf(fd, "%ld", &red);
  311.       state++;
  312.       break;
  313.     case 1:
  314.       ungetc(z, fd);
  315.       fscanf(fd, "%ld", &green);
  316.       state++;
  317.       break;
  318.     case 2:
  319.       ungetc(z, fd);
  320.       fscanf(fd, "%ld", &blue);
  321.  
  322.       *pixel_black  = 0;
  323.       *pixel_red    = (green != (char)pnm_info.colors);
  324.       *pixel_blue   = (red   != (char)pnm_info.colors);
  325.       *pixel_yellow = (blue  != (char)pnm_info.colors);
  326.  
  327.       if(*pixel_red && *pixel_blue && *pixel_yellow) {
  328.         *pixel_black = 1;
  329.         *pixel_yellow = *pixel_red = *pixel_blue = 0;
  330.       }
  331.  
  332.       return(0);
  333.       break;
  334.     }
  335.     break;
  336.  
  337.       case EOF:
  338.     return(1);
  339.       }
  340.     }
  341.   }
  342.  
  343.   return(0);
  344. }
  345.  
  346. #ifdef __STDC__
  347. static int pgm_get_pixel_color_binary(int *pixel_yellow, int *pixel_red,
  348.                       int *pixel_blue, int *pixel_black,
  349.                       FILE *fd)
  350. #else
  351. static int pgm_get_pixel_color_binary(pixel_yellow, pixel_red,
  352.                       pixel_blue, pixel_black,
  353.                       fd)
  354. int *pixel_yellow;
  355. int *pixel_red;
  356. int *pixel_blue;
  357. int *pixel_black;
  358. FILE *fd;
  359. #endif
  360. {
  361.   char c;
  362.  
  363.   if(pixel_yellow) {
  364.     fread(&c, 1, 1, fd);
  365.  
  366.     *pixel_yellow = *pixel_red = *pixel_blue = 0;
  367.     *pixel_black = (c != (char)pnm_info.colors);
  368.   }
  369.  
  370.   return(0);
  371. }
  372.  
  373. #ifdef __STDC__
  374. static int pgm_get_pixel_color_ascii(int *pixel_yellow, int *pixel_red,
  375.                      int *pixel_blue, int *pixel_black,
  376.                      FILE *fd)
  377. #else
  378. static int pgm_get_pixel_color_ascii(pixel_yellow, pixel_red,
  379.                      pixel_blue, pixel_black,
  380.                      fd)
  381. int *pixel_yellow;
  382. int *pixel_red;
  383. int *pixel_blue;
  384. int *pixel_black;
  385. FILE *fd;
  386. #endif
  387. {
  388.   int z;
  389.   long lz;
  390.  
  391.   if(pixel_yellow) {
  392.     while(1) {
  393.       switch(z = fgetc(fd)) {
  394.  
  395.     /* ignore whitespaces */
  396.       case ' ':
  397.       case '\t':
  398.       case '\n':
  399.       case '\r':
  400.     break;
  401.  
  402.     /* ignoring lines with # */
  403.       case '#':
  404.     while((z = fgetc(fd)) != '\n' && z != EOF);
  405.     break;
  406.  
  407.       default:
  408.     ungetc(z, fd);
  409.     fscanf(fd, "%ld", &lz);
  410.  
  411.     *pixel_yellow = *pixel_red = *pixel_blue = 0;
  412.  
  413.     *pixel_black = (lz != pnm_info.colors);
  414.     return(0);
  415.  
  416.       case EOF:
  417.     return(1);
  418.       }
  419.     }
  420.   }
  421.  
  422.   return(0);
  423. }
  424.  
  425. #ifdef __STDC__
  426. static int pbm_get_pixel_color_binary(int *pixel_yellow, int *pixel_red,
  427.                       int *pixel_blue, int *pixel_black,
  428.                       FILE *fd)
  429. #else
  430. static int pbm_get_pixel_color_binary(pixel_yellow, pixel_red,
  431.                       pixel_blue, pixel_black,
  432.                       fd)
  433. int *pixel_yellow;
  434. int *pixel_red;
  435. int *pixel_blue;
  436. int *pixel_black;
  437. FILE *fd;
  438. #endif
  439. {
  440.   static int bit = 8;
  441.   static char c;
  442.  
  443.   /* for masking the right bit */
  444.   static char bit_value[8] = {
  445.     128,
  446.     64,
  447.     32,
  448.     16,
  449.     8,
  450.     4,
  451.     2,
  452.     1
  453.   };
  454.  
  455.   if(pixel_yellow) {
  456.     if(bit > 7) {
  457.       bit = 0;
  458.       fread(&c, 1, 1, fd);
  459.     }
  460.  
  461.     *pixel_yellow = *pixel_red = *pixel_blue = 0;
  462.  
  463.     *pixel_black = c & bit_value[bit++];
  464.  
  465.   } else {
  466.     /* end of scan line */
  467.     if(bit) {
  468.       bit = 8;
  469.     }
  470.   }
  471.  
  472.   return(0);
  473. }
  474.  
  475. #ifdef __STDC__
  476. static int pbm_get_pixel_color_ascii(int *pixel_yellow, int *pixel_red,
  477.                      int *pixel_blue, int *pixel_black,
  478.                      FILE *fd)
  479. #else
  480. static int pbm_get_pixel_color_ascii(pixel_yellow, pixel_red,
  481.                      pixel_blue, pixel_black,
  482.                      fd)
  483. int *pixel_yellow;
  484. int *pixel_red;
  485. int *pixel_blue;
  486. int *pixel_black;
  487. FILE *fd;
  488. #endif
  489. {
  490.   int z;
  491.  
  492.   if(pixel_yellow) {
  493.  
  494.     *pixel_yellow = *pixel_red = *pixel_blue = 0;
  495.  
  496.     while(1) {
  497.       switch(fgetc(fd)) {
  498.  
  499.     /* ignore whitespaces */
  500.       case ' ':
  501.       case '\t':
  502.       case '\n':
  503.       case '\r':
  504.     break;
  505.  
  506.     /* ignoring lines with # */
  507.       case '#':
  508.     while((z = fgetc(fd)) != '\n' && z != EOF);
  509.     break;
  510.  
  511.       case '1':
  512.     *pixel_black = 1;
  513.     return(0);
  514.  
  515.       case '0':
  516.  
  517.     *pixel_black = 0;
  518.     return(0);
  519.  
  520.       default:
  521.     return(1);
  522.       }
  523.     }
  524.   }
  525. }
  526.  
  527. #ifdef __STDC__
  528. Pnm_Info *pnm_get_info(FILE *fd)
  529. #else
  530. Pnm_Info *pnm_get_info(fd)
  531. FILE *fd;
  532. #endif
  533. {
  534.   int loop;
  535.   int c;
  536.   int state;
  537.  
  538.   loop = 1;
  539.   state = 0;
  540.  
  541.   /* reading pnm file */
  542.   while(loop) {
  543.     switch(c = fgetc(fd)) {
  544.  
  545.       /* ignore whitespaces */
  546.     case ' ':
  547.     case '\t':
  548.     case '\n':
  549.     case '\r':
  550.       break;
  551.  
  552.       /* ignoring lines with # */
  553.     case '#':
  554.       while((c = fgetc(fd)) != '\n' && c != EOF);
  555.       break;
  556.  
  557.       /* EOF -> error */
  558.     case EOF:
  559.       return(NULL);
  560.  
  561.     default:
  562.       ungetc(c, fd);
  563.  
  564.       /* reading header info */
  565.       switch(state) {
  566.       case 0:
  567.     fscanf(fd, "%2s", pnm_info.magic);
  568.     state++;
  569.  
  570.     if(pnm_info.magic[0] != 'P')
  571.       return(NULL);
  572.  
  573.     switch(pnm_info.magic[1]) {
  574.  
  575.     case '1':
  576.       pnm_info.binary = 0;
  577.       pnm_info.type = PBM;
  578.       pnm_info.get_pixel_mono  = pbm_get_pixel_mono_ascii;
  579.       pnm_info.get_pixel_color = pbm_get_pixel_color_ascii;
  580.       break;
  581.  
  582.     case '2':
  583.       pnm_info.binary = 0;
  584.       pnm_info.type = PGM;
  585.       pnm_info.get_pixel_mono  = pgm_get_pixel_mono_ascii;
  586.       pnm_info.get_pixel_color = pgm_get_pixel_color_ascii;
  587.       break;
  588.  
  589.     case '3':
  590.       pnm_info.binary = 0;
  591.       pnm_info.type = PPM;
  592.       pnm_info.get_pixel_mono  = ppm_get_pixel_mono_ascii;
  593.       pnm_info.get_pixel_color = ppm_get_pixel_color_ascii;
  594.       break;
  595.  
  596.     case '4':
  597.       pnm_info.binary = 1;
  598.       pnm_info.type = PBM;
  599.       pnm_info.get_pixel_mono  = pbm_get_pixel_mono_binary;
  600.       pnm_info.get_pixel_color = pbm_get_pixel_color_binary;
  601.       break;
  602.  
  603.     case '5':
  604.       pnm_info.binary = 1;
  605.       pnm_info.type = PGM;
  606.       pnm_info.get_pixel_mono  = pgm_get_pixel_mono_binary;
  607.       pnm_info.get_pixel_color = pgm_get_pixel_color_binary;
  608.       break;
  609.  
  610.     case '6':
  611.       pnm_info.binary = 1;
  612.       pnm_info.type = PPM;
  613.       pnm_info.get_pixel_mono  = ppm_get_pixel_mono_binary;
  614.       pnm_info.get_pixel_color = ppm_get_pixel_color_binary;
  615.       break;
  616.  
  617.     default:
  618.       return(NULL);
  619.     }
  620.  
  621.     break;
  622.  
  623.       case 1:
  624.     fscanf(fd, "%ld", &pnm_info.width);
  625.     state++;
  626.     break;
  627.  
  628.       case 2:
  629.     fscanf(fd, "%ld", &pnm_info.height);
  630.     state++;
  631.  
  632.     if(pnm_info.type == PBM)
  633.       state++;
  634.  
  635.     break;
  636.  
  637.       case 3:
  638.     fscanf(fd, "%ld", &pnm_info.colors);
  639.     state++;
  640.     break;
  641.  
  642.       case 4:
  643.     loop = 0;
  644.     break;
  645.       }
  646.  
  647.       break;
  648.     }
  649.   }
  650.  
  651.   return(&pnm_info);
  652. }
  653.